⚡️ Speed up function `is_repo_a_fork` by 40% in PR #371 (`chore/error-on-missing-key-in-fork`) by codeflash-ai[bot] · Pull Request #372 · codeflash-ai/codeflash

codeflash-ai · 2025-06-24T00:35:07Z

⚡️ This pull request contains optimizations for PR #371

If you approve this dependent PR, these changes will be merged into the original PR branch chore/error-on-missing-key-in-fork.

This PR will be automatically closed if the original PR is merged.

📄 40% (0.40x) speedup for `is_repo_a_fork` in `codeflash/code_utils/env_utils.py`

⏱️ Runtime : 50.5 microseconds → 36.0 microseconds (best of 91 runs)

📝 Explanation and details

Here’s a faster version, making these improvements.

Avoid repeatedly calling os.getenv() and Path.open() for the same event file, by using an explicit cache variable for the file contents. This accelerates repeated lookups and reduces disk accesses.
Remove double @lru_cache use, as the value from get_cached_gh_event_data() will not change for a process lifetime and can be memory-cached explicitly.
Microoptimize the is_repo_a_fork logic by removing an unnecessary bool(...) coercion (the value is already True/False).

Here’s the rewritten program.

Key notes:

The event file is read at most once per process.
All redundant calls and mutable global state are avoided.
Fast subsequent access due to a module-level cache; you’ll see lower file-system and JSON load latency.
The returned values are identical for the same environment and state, and function signatures are maintained.

Let me know if you want further micro-optimizations!

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 37 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	77.8%

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import json
import os
from functools import lru_cache
from pathlib import Path
from tempfile import NamedTemporaryFile
from typing import Any

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.env_utils import is_repo_a_fork


def write_event_file(data: dict[str, Any]) -> str:
    """Helper to write event data to a temp file and return its path."""
    with NamedTemporaryFile('w', delete=False) as tmp:
        json.dump(data, tmp)
        tmp.flush()
        return tmp.name

def remove_file(path: str):
    """Helper to remove temp files."""
    try:
        os.remove(path)
    except Exception:
        pass

# 1. Basic Test Cases

def test_fork_true(monkeypatch):
    """Test when repository is a fork (fork: True)."""
    event = {"repository": {"fork": True}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.53μs -> 1.12μs (36.5% faster)
    remove_file(path)

def test_fork_false(monkeypatch):
    """Test when repository is not a fork (fork: False)."""
    event = {"repository": {"fork": False}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.44μs -> 1.03μs (39.8% faster)
    remove_file(path)

def test_fork_int_true(monkeypatch):
    """Test when repository['fork'] is 1 (should be truthy)."""
    event = {"repository": {"fork": 1}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.41μs -> 982ns (43.9% faster)
    remove_file(path)

def test_fork_int_false(monkeypatch):
    """Test when repository['fork'] is 0 (should be falsy)."""
    event = {"repository": {"fork": 0}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.43μs -> 992ns (44.5% faster)
    remove_file(path)

def test_fork_string_true(monkeypatch):
    """Test when repository['fork'] is 'true' (should be truthy as non-empty string)."""
    event = {"repository": {"fork": "true"}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.45μs -> 992ns (46.5% faster)
    remove_file(path)

def test_fork_string_false(monkeypatch):
    """Test when repository['fork'] is '' (empty string, should be falsy)."""
    event = {"repository": {"fork": ""}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.41μs -> 952ns (48.4% faster)
    remove_file(path)

# 2. Edge Test Cases

def test_no_github_event_path(monkeypatch):
    """Test when GITHUB_EVENT_PATH is not set (should return False)."""
    monkeypatch.delenv("GITHUB_EVENT_PATH", raising=False)
    codeflash_output = is_repo_a_fork() # 1.27μs -> 891ns (42.8% faster)

def test_github_event_path_empty(monkeypatch):
    """Test when GITHUB_EVENT_PATH is set to empty string (should return False)."""
    monkeypatch.setenv("GITHUB_EVENT_PATH", "")
    codeflash_output = is_repo_a_fork() # 1.17μs -> 842ns (39.2% faster)





def test_fork_null(monkeypatch):
    """Test when 'fork' is None (should be falsy)."""
    event = {"repository": {"fork": None}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.54μs -> 1.06μs (45.3% faster)
    remove_file(path)

def test_fork_list(monkeypatch):
    """Test when 'fork' is a non-empty list (should be truthy)."""
    event = {"repository": {"fork": [1]}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.44μs -> 1.00μs (44.1% faster)
    remove_file(path)

def test_fork_empty_list(monkeypatch):
    """Test when 'fork' is an empty list (should be falsy)."""
    event = {"repository": {"fork": []}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork() # 1.42μs -> 1.01μs (40.6% faster)
    remove_file(path)

# 3. Large Scale Test Cases

def test_large_event_file_fork_true(monkeypatch):
    """Test with a large event file (fork: True) and many unrelated keys."""
    # Create a large event dict with many unrelated keys
    event = {"repository": {"fork": True}}
    # Add 999 unrelated keys
    for i in range(999):
        event[f"unrelated_{i}"] = {"data": i}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork()
    remove_file(path)

def test_large_event_file_fork_false(monkeypatch):
    """Test with a large event file (fork: False) and many unrelated keys."""
    event = {"repository": {"fork": False}}
    for i in range(999):
        event[f"unrelated_{i}"] = {"data": i}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork()
    remove_file(path)

def test_large_repository_dict(monkeypatch):
    """Test with a large 'repository' dict but correct 'fork' key."""
    repository = {"fork": True}
    # Add 999 unrelated keys to repository
    for i in range(999):
        repository[f"unrelated_{i}"] = i
    event = {"repository": repository}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    codeflash_output = is_repo_a_fork()
    remove_file(path)

def test_multiple_calls_cache(monkeypatch):
    """Test that repeated calls return the same result due to lru_cache."""
    event = {"repository": {"fork": False}}
    path = write_event_file(event)
    monkeypatch.setenv("GITHUB_EVENT_PATH", path)
    # First call
    codeflash_output = is_repo_a_fork() # 1.42μs -> 942ns (51.1% faster)
    # Change file content to fork: True (should not affect due to cache)
    with open(path, "w") as f:
        json.dump({"repository": {"fork": True}}, f)
    # Second call should still return False due to cache
    codeflash_output = is_repo_a_fork()
    remove_file(path)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import json
import os
import tempfile
from functools import lru_cache
from pathlib import Path
from typing import Any

# imports
import pytest  # used for our unit tests
from codeflash.code_utils.env_utils import is_repo_a_fork

# --- Basic Test Cases ---

def test_no_github_event_path_env():
    # GITHUB_EVENT_PATH is not set; should return False
    codeflash_output = is_repo_a_fork() # 1.30μs -> 892ns (46.0% faster)

def test_empty_github_event_path(monkeypatch):
    # GITHUB_EVENT_PATH is set to empty string; should return False
    monkeypatch.setenv("GITHUB_EVENT_PATH", "")
    codeflash_output = is_repo_a_fork() # 1.15μs -> 822ns (40.1% faster)

def test_valid_fork_true(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a file with repository.fork == True
    event = {"repository": {"fork": True}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.51μs -> 1.10μs (37.3% faster)

def test_valid_fork_false(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a file with repository.fork == False
    event = {"repository": {"fork": False}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.51μs -> 1.09μs (38.6% faster)

def test_valid_fork_int_true(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a file with repository.fork == 1 (truthy)
    event = {"repository": {"fork": 1}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.53μs -> 1.05μs (45.7% faster)

def test_valid_fork_int_false(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a file with repository.fork == 0 (falsy)
    event = {"repository": {"fork": 0}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.51μs -> 1.05μs (43.8% faster)

# --- Edge Test Cases ---





def test_github_event_path_json_fork_null(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as null; bool(None) is False
    event = {"repository": {"fork": None}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.57μs -> 1.04μs (51.1% faster)

def test_github_event_path_json_fork_string_true(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as "True" (non-empty string is True)
    event = {"repository": {"fork": "True"}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.58μs -> 1.09μs (45.0% faster)

def test_github_event_path_json_fork_string_false(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as "False" (non-empty string is True)
    event = {"repository": {"fork": "False"}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    # bool("False") is True in Python
    codeflash_output = is_repo_a_fork() # 1.54μs -> 1.09μs (41.2% faster)

def test_github_event_path_json_fork_empty_string(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as "" (empty string is False)
    event = {"repository": {"fork": ""}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.48μs -> 1.10μs (34.6% faster)

def test_github_event_path_json_fork_list(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as a non-empty list (True)
    event = {"repository": {"fork": [1, 2, 3]}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.48μs -> 1.07μs (38.3% faster)

def test_github_event_path_json_fork_empty_list(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as an empty list (False)
    event = {"repository": {"fork": []}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.51μs -> 1.03μs (46.6% faster)

def test_github_event_path_json_fork_dict(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as a non-empty dict (True)
    event = {"repository": {"fork": {"foo": "bar"}}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.53μs -> 1.09μs (40.4% faster)

def test_github_event_path_json_fork_empty_dict(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as an empty dict (False)
    event = {"repository": {"fork": {}}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.46μs -> 1.08μs (35.1% faster)

# --- Large Scale Test Cases ---

def test_large_json_file_fork_true(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a large JSON file with many keys, but repository.fork == True
    large_data = {f"key_{i}": i for i in range(500)}
    large_data["repository"] = {"fork": True}
    event_path = tmp_path / "large_event.json"
    event_path.write_text(json.dumps(large_data))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.59μs -> 1.09μs (45.8% faster)

def test_large_json_file_fork_false(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a large JSON file with many keys, but repository.fork == False
    large_data = {f"key_{i}": i for i in range(500)}
    large_data["repository"] = {"fork": False}
    event_path = tmp_path / "large_event.json"
    event_path.write_text(json.dumps(large_data))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.56μs -> 1.07μs (45.8% faster)

def test_large_nested_json(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a large deeply nested JSON, but repository.fork == True
    nested = {"level1": {"level2": {"level3": [i for i in range(200)]}}}
    event = {"repository": {"fork": True}, "other": nested}
    event_path = tmp_path / "nested_event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.54μs -> 1.07μs (43.9% faster)

def test_large_list_in_fork(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as a large non-empty list (True)
    event = {"repository": {"fork": [i for i in range(999)]}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.52μs -> 1.10μs (38.1% faster)

def test_large_empty_list_in_fork(monkeypatch, tmp_path):
    # GITHUB_EVENT_PATH points to a JSON file with 'fork' as a large empty list (False)
    event = {"repository": {"fork": []}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    codeflash_output = is_repo_a_fork() # 1.56μs -> 1.04μs (50.0% faster)

def test_multiple_calls_cache(monkeypatch, tmp_path):
    # Ensure repeated calls use cached result and don't reread file (indirectly)
    event = {"repository": {"fork": True}}
    event_path = tmp_path / "event.json"
    event_path.write_text(json.dumps(event))
    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_path))
    # First call should return True
    codeflash_output = is_repo_a_fork()
    # Change file content to fork=False, but cache should keep returning True
    event_path.write_text(json.dumps({"repository": {"fork": False}}))
    codeflash_output = is_repo_a_fork()  # cache is used
    # Clear cache and now should return False
    is_repo_a_fork.cache_clear()
    get_cached_gh_event_data.cache_clear()
    codeflash_output = is_repo_a_fork()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr371-2025-06-24T00.35.01 and push.

…-on-missing-key-in-fork`) Here’s a **faster** version, making these improvements. - Avoid repeatedly calling `os.getenv()` and `Path.open()` for the same event file, by using an explicit cache variable for the file contents. This accelerates repeated lookups and reduces disk accesses. - Remove double @lru_cache use, as the value from `get_cached_gh_event_data()` will not change for a process lifetime and can be memory-cached explicitly. - Microoptimize the `is_repo_a_fork` logic by removing an unnecessary bool(...) coercion (the value is already True/False). Here’s the rewritten program. **Key notes:** - The event file is read at most once per process. - All redundant calls and mutable global state are avoided. - Fast subsequent access due to a module-level cache; you’ll see lower file-system and JSON load latency. - The returned values are identical for the same environment and state, and function signatures are maintained. Let me know if you want further micro-optimizations!

codeflash-ai · 2025-06-26T15:57:57Z

This PR has been automatically closed because the original PR #371 by mohammedahmed18 was closed.

codeflash-ai Bot added the ⚡️ codeflash Optimization PR opened by Codeflash AI label Jun 24, 2025

codeflash-ai Bot mentioned this pull request Jun 24, 2025

[Chore] Error message on missing API key for forks (CF-675) #371

Merged

codeflash-ai Bot closed this Jun 26, 2025

codeflash-ai Bot deleted the codeflash/optimize-pr371-2025-06-24T00.35.01 branch June 26, 2025 15:58

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

⚡️ Speed up function `is_repo_a_fork` by 40% in PR #371 (`chore/error-on-missing-key-in-fork`)#372

⚡️ Speed up function `is_repo_a_fork` by 40% in PR #371 (`chore/error-on-missing-key-in-fork`)#372
codeflash-ai[bot] wants to merge 1 commit into
chore/error-on-missing-key-in-forkfrom
codeflash/optimize-pr371-2025-06-24T00.35.01

codeflash-ai Bot commented Jun 24, 2025

Uh oh!

codeflash-ai Bot commented Jun 26, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

Conversation

codeflash-ai Bot commented Jun 24, 2025

⚡️ This pull request contains optimizations for PR #371

📄 40% (0.40x) speedup for is_repo_a_fork in codeflash/code_utils/env_utils.py

📝 Explanation and details

Uh oh!

codeflash-ai Bot commented Jun 26, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

0 participants

📄 40% (0.40x) speedup for `is_repo_a_fork` in `codeflash/code_utils/env_utils.py`